home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Screenblankers / GBlanker / GSource / Blankers / Puzzle / blank.c next >
C/C++ Source or Header  |  1996-09-26  |  5KB  |  230 lines
  1. /*
  2.  *  Copyright (c) 1994 Michael D. Bayne.
  3.  *  All rights reserved.
  4.  *
  5.  *  Please see the documentation accompanying the distribution for distribution
  6.  *  and disclaimer information.
  7.  */
  8.  
  9. #include <exec/memory.h>
  10. #include "/includes.h"
  11.  
  12. #define STEP_DELAY Prefs[DELAY].po_Level
  13.  
  14. #define HORIZ   0
  15. #define VERT    2
  16. #define DIVIS   4
  17. #define DELAY   6
  18. #define SCREEN  8
  19. #define FADEPCT 10
  20.  
  21. typedef struct _mPoint
  22. {
  23.     LONG x;
  24.     LONG y;
  25. } mPoint;
  26.  
  27. #define UP      0
  28. #define DOWN    1
  29. #define LEFT    2
  30. #define RIGHT   3
  31.  
  32. #include "Puzzle_rev.h"
  33. STATIC const UBYTE VersTag[] = VERSTAG;
  34.  
  35. VOID Defaults( PrefObject *Prefs )
  36. {
  37.     Prefs[HORIZ].po_Level = 7;
  38.     Prefs[VERT].po_Level = 5;
  39.     Prefs[DIVIS].po_Level = 5;
  40.     Prefs[DELAY].po_Level = 5;
  41.     Prefs[SCREEN].po_Active = 0;
  42.     Prefs[FADEPCT].po_Level = 10;
  43. }
  44.  
  45. LONG getNewDir( LONG x, LONG y, LONG xmax, LONG ymax, LONG olddir )
  46. {
  47.     LONG a1[] = { UP, DOWN, LEFT, RIGHT }, dir;
  48.     LONG a2[] = { DOWN, UP, RIGHT, LEFT };
  49.  
  50.     do
  51.     {
  52.         switch( dir = RangeRand( 4 ))
  53.         {
  54.         case RIGHT: if( !x ) dir = LEFT; break;
  55.         case LEFT: if( x > xmax ) dir = RIGHT; break;
  56.         case DOWN: if( !y ) dir = UP; break;
  57.         case UP: if( y > ymax ) dir = DOWN; break;
  58.         }
  59.     }
  60.     while( a1[dir] == a2[olddir] );
  61.     
  62.     return dir;
  63. }
  64.  
  65. LONG Blank( PrefObject *Prefs )
  66. {
  67.     LONG i, dir = UP, xmax, ymax, wid, hei, Width, Height, Divs;
  68.     mPoint c = { 0, 0 }, n = { 0, 0 }, t;
  69.     LONG RetVal = OK, ToFrontCount = 0;
  70.     struct Screen *PScr;
  71.     struct Window *Wnd;
  72.     struct RastPort *Rast;
  73.     
  74.     if( PScr = cloneTopScreen( FALSE, Prefs[SCREEN].po_Active ))
  75.     {
  76.         if( Prefs[FADEPCT].po_Level )
  77.         {
  78.             ULONG *ColorTable, PctCount, BPG;
  79.  
  80.             ColorTable = GetColorTable( PScr );
  81.             BPG = AvgBitsPerGun( getTopScreenMode());
  82.             PctCount = ( 1L << BPG ) * Prefs[FADEPCT].po_Level / 100;
  83.             for( i = 0; i < PctCount; i++ )
  84.                 FadeAndLoadTable( PScr, BPG, ColorTable, 0 );
  85.         }
  86.         
  87.         Rast = &( PScr->RastPort );
  88.         Width = PScr->Width;
  89.         Height = PScr->Height;
  90.         if( Prefs[HORIZ].po_Level )
  91.             wid = Width / Prefs[HORIZ].po_Level;
  92.         else
  93.             wid = Width / 3;
  94.         if( Prefs[VERT].po_Level )
  95.             hei = Height / Prefs[VERT].po_Level;
  96.         else
  97.             hei = Height / 3;
  98.         if( Prefs[DIVIS].po_Level )
  99.             Divs = Prefs[DIVIS].po_Level;
  100.         else
  101.             Divs = 4;
  102.         
  103.         SetAPen( Rast, 2 );
  104.         for( i = 0; i < Width; i += wid )
  105.         {
  106.             Move( Rast, i, 0 );
  107.             Draw( Rast, i, Height-1 );
  108.         }
  109.         for( i = 0; i < Height; i += hei )
  110.         {
  111.             Move( Rast, 0, i );
  112.             Draw( Rast, Width-1, i );
  113.         }
  114.         
  115.         SetAPen( Rast, 1 );
  116.         for( i = wid-1; i < Width; i += wid )
  117.         {
  118.             Move( Rast, i, 0 );
  119.             Draw( Rast, i, Height-1 );
  120.         }
  121.         for( i = hei-1; i < Height; i += hei )
  122.         {
  123.             Move( Rast, 0, i );
  124.             Draw( Rast, Width-1, i );
  125.         }
  126.         
  127.         xmax = Width - 2 * wid;
  128.         ymax = Height - 2 * hei;
  129.         
  130.         SetAPen( Rast, 3 );
  131.         
  132.         Wnd = BlankMousePointer( PScr );
  133.         
  134.         while( RetVal == OK )
  135.         {
  136.             LONG step, i;
  137.  
  138.             if(!( ++ToFrontCount % 60 ))
  139.                 ScreenToFront( PScr );
  140.             
  141.             switch( dir = getNewDir( c.x, c.y, xmax, ymax, dir ))
  142.             {
  143.             case UP:
  144.                 n.y += hei;
  145.                 t = n;
  146.                 step = ( n.y - c.y ) / Divs;
  147.                 do
  148.                 {
  149.                     if( step > t.y - c.y )
  150.                         step = t.y - c.y;
  151.                     t.y -= step;
  152.                     for( i = 0; i < STEP_DELAY; i++ )
  153.                         WaitTOF();
  154.                     BltBitMap( Rast->BitMap, t.x, t.y + step, Rast->BitMap,
  155.                               t.x, t.y, wid, hei, 0xC0, 0xFF, 0L );
  156.                     RectFill( Rast, t.x, t.y + hei, t.x + wid - 1,
  157.                              t.y + hei + step - 1 );
  158.                     RetVal = ContinueBlanking();
  159.                 }
  160.                 while( t.y > c.y && RetVal == OK );
  161.                 break;
  162.             case DOWN:
  163.                 n.y -= hei;
  164.                 t = n;
  165.                 step = ( c.y - n.y ) / Divs;
  166.                 do
  167.                 {
  168.                     if( step > c.y - t.y )
  169.                         step = c.y - t.y;
  170.                     t.y += step;
  171.                     for( i = 0; i < STEP_DELAY; i++ )
  172.                         WaitTOF();
  173.                     BltBitMap( Rast->BitMap, t.x, t.y - step, Rast->BitMap,
  174.                               t.x, t.y, wid, hei, 0xC0, 0xFF, 0L );
  175.                     RectFill( Rast, t.x, t.y - step, t.x + wid - 1, t.y - 1 );
  176.                     RetVal = ContinueBlanking();
  177.                 }
  178.                 while( t.y < c.y && RetVal == OK );
  179.                 break;
  180.             case LEFT:
  181.                 n.x += wid;
  182.                 t = n;
  183.                 step = ( n.x - c.x ) / Divs;
  184.                 do
  185.                 {
  186.                     if( step > t.x - c.x )
  187.                         step = t.x - c.x;
  188.                     t.x -= step;
  189.                     for( i = 0; i < STEP_DELAY; i++ )
  190.                         WaitTOF();
  191.                     BltBitMap( Rast->BitMap, t.x + step, t.y, Rast->BitMap,
  192.                               t.x, t.y, wid, hei, 0xC0, 0xFF, 0L );
  193.                     RectFill( Rast, t.x + wid, t.y, t.x + wid + step - 1,
  194.                              t.y + hei - 1 );
  195.                     RetVal = ContinueBlanking();
  196.                 }
  197.                 while( t.x > c.x && RetVal == OK );
  198.                 break;
  199.             case RIGHT:
  200.                 n.x -= wid;
  201.                 t = n;
  202.                 step = ( c.x - n.x ) / Divs;
  203.                 do
  204.                 {
  205.                     if( step > c.x - t.x )
  206.                         step = c.x - t.x;
  207.                     t.x += step;
  208.                     for( i = 0; i < STEP_DELAY; i++ )
  209.                         WaitTOF();
  210.                     BltBitMap( Rast->BitMap, t.x - step, t.y, Rast->BitMap,
  211.                               t.x, t.y, wid, hei, 0xC0, 0xFF, 0L );
  212.                     RectFill( Rast, t.x - step, t.y, t.x - 1, t.y + hei - 1 );
  213.                     RetVal = ContinueBlanking();
  214.                 }
  215.                 while( t.x < c.x && RetVal == OK );
  216.                 break;
  217.             }
  218.  
  219.             c = n;
  220.         }
  221.         
  222.         UnblankMousePointer( Wnd );
  223.         CloseScreen( PScr );
  224.     }
  225.     else
  226.         RetVal = FAILED;
  227.         
  228.     return RetVal;
  229. }
  230.